home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1999 July: Mac OS SDK / Dev.CD Jul 99 SDK1.toast / Development Kits / Mac OS / OpenGL 1.0 SDK / Source / Libraries / glut / glut_get.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-05-18  |  5.8 KB  |  242 lines  |  [TEXT/CWIE]
  1.  
  2. /* Copyright (c) Mark J. Kilgard, 1994. */
  3.  
  4. /* This program is freely distributable without licensing fees
  5.    and is provided without guarantee or warrantee expressed or
  6.    implied. This program is -not- in the public domain. */
  7.  
  8. #include <QDOffscreen.h>
  9.  
  10. #include "glut.h"
  11. #include "glutint.h"
  12.  
  13. #include <stdlib.h>
  14.  
  15. #define GET_CONFIG(attrib)\
  16. {\
  17.     if(!__glutCurrentWindow)\
  18.     {\
  19.         __glutWarning("glutGet: no active window");\
  20.         return -1;\
  21.     }\
  22. \
  23.     if(__glutCurrentWindow->renderWin == __glutCurrentWindow->win)\
  24.     {\
  25.         aglDescribePixelFormat(__glutCurrentWindow->vis, attrib, &value);\
  26.     }\
  27. }
  28.  
  29. int glutGet(GLenum param)
  30. {
  31.     CWindowPtr win;
  32.     Rect *l_rect, *g_rect;
  33.     PixMapHandle pixmap;
  34.     GLint x, y, value;
  35.     unsigned int width, height;
  36.  
  37.     switch (param)
  38.     {
  39.         case GLUT_INIT_WINDOW_X:
  40.             return __glutInitX;
  41.         case GLUT_INIT_WINDOW_Y:
  42.             return __glutInitY;
  43.         case GLUT_INIT_WINDOW_WIDTH:
  44.             return __glutInitWidth;
  45.         case GLUT_INIT_WINDOW_HEIGHT:
  46.             return __glutInitHeight;
  47.         case GLUT_INIT_DISPLAY_MODE:
  48.             return __glutDisplayMode;
  49.         case GLUT_WINDOW_X:
  50.             if(!__glutCurrentWindow)
  51.             {
  52.                 __glutWarning("glutGet: no active window");
  53.                 return -1;
  54.             }
  55.             
  56.             if(__glutCurrentWindow->fullscreen) return 0;
  57.             
  58.             win = __glutCurrentWindow->win;
  59.             pixmap = GetGWorldPixMap(win);
  60.             g_rect = &(**pixmap).bounds;
  61.             x = -g_rect->left;
  62.             return x;
  63.         case GLUT_WINDOW_Y:
  64.             if(!__glutCurrentWindow)
  65.             {
  66.                 __glutWarning("glutGet: no active window");
  67.                 return -1;
  68.             }
  69.             
  70.             if(__glutCurrentWindow->fullscreen) return 0;
  71.             
  72.             win = __glutCurrentWindow->win;
  73.             pixmap = GetGWorldPixMap(win);
  74.             g_rect = &(**pixmap).bounds;
  75.             l_rect = &win->portRect;
  76.             y = -g_rect->top + l_rect->bottom;
  77.             return y;
  78.         case GLUT_WINDOW_WIDTH:
  79.             if(!__glutCurrentWindow)
  80.             {
  81.                 __glutWarning("glutGet: no active window");
  82.                 return -1;
  83.             }
  84.             
  85.             if(__glutCurrentWindow->fullscreen) return __glutCurrentWindow->width;
  86.             
  87.             if(!__glutCurrentWindow->reshape)
  88.             {
  89.                 win = __glutCurrentWindow->win;
  90.                 pixmap = GetGWorldPixMap(win);
  91.                 g_rect = &(**pixmap).bounds;
  92.                 l_rect = &win->portRect;
  93.                 width  = l_rect->right;
  94.                 return width;
  95.             }
  96.             return __glutCurrentWindow->width;
  97.         case GLUT_WINDOW_HEIGHT:
  98.             if(!__glutCurrentWindow)
  99.             {
  100.                 __glutWarning("glutGet: no active window");
  101.                 return -1;
  102.             }
  103.             
  104.             if(__glutCurrentWindow->fullscreen) return __glutCurrentWindow->height;
  105.             
  106.             if(!__glutCurrentWindow->reshape)
  107.             {
  108.                 win = __glutCurrentWindow->win;
  109.                 pixmap = GetGWorldPixMap(win);
  110.                 g_rect = &(**pixmap).bounds;
  111.                 l_rect = &win->portRect;
  112.                 height = l_rect->bottom;
  113.                 return height;
  114.             }
  115.             return __glutCurrentWindow->height;
  116.         case GLUT_WINDOW_BUFFER_SIZE:
  117.             GET_CONFIG(AGL_BUFFER_SIZE);
  118.             return value;
  119.         case GLUT_WINDOW_STENCIL_SIZE:
  120.             GET_CONFIG(AGL_STENCIL_SIZE);
  121.             return value;
  122.         case GLUT_WINDOW_DEPTH_SIZE:
  123.             GET_CONFIG(AGL_DEPTH_SIZE);
  124.             return value;
  125.         case GLUT_WINDOW_RED_SIZE:
  126.             GET_CONFIG(AGL_RED_SIZE);
  127.             return value;
  128.         case GLUT_WINDOW_GREEN_SIZE:
  129.             GET_CONFIG(AGL_GREEN_SIZE);
  130.             return value;
  131.         case GLUT_WINDOW_BLUE_SIZE:
  132.             GET_CONFIG(AGL_BLUE_SIZE);
  133.             return value;
  134.         case GLUT_WINDOW_ALPHA_SIZE:
  135.             GET_CONFIG(AGL_ALPHA_SIZE);
  136.             return value;
  137.         case GLUT_WINDOW_ACCUM_RED_SIZE:
  138.             GET_CONFIG(AGL_ACCUM_RED_SIZE);
  139.             return value;
  140.         case GLUT_WINDOW_ACCUM_GREEN_SIZE:
  141.             GET_CONFIG(AGL_ACCUM_GREEN_SIZE);
  142.             return value;
  143.         case GLUT_WINDOW_ACCUM_BLUE_SIZE:
  144.             GET_CONFIG(AGL_ACCUM_BLUE_SIZE);
  145.             return value;
  146.         case GLUT_WINDOW_ACCUM_ALPHA_SIZE:
  147.             GET_CONFIG(AGL_ACCUM_ALPHA_SIZE);
  148.             return value;
  149.         case GLUT_WINDOW_DOUBLEBUFFER:
  150.             GET_CONFIG(AGL_DOUBLEBUFFER);
  151.             return value;
  152.         case GLUT_WINDOW_RGBA:
  153.             GET_CONFIG(AGL_RGBA);
  154.             return value;
  155.         case GLUT_WINDOW_COLORMAP_SIZE:
  156.             GET_CONFIG(AGL_RGBA);
  157.             return 0;
  158.         case GLUT_WINDOW_PARENT:
  159.             if(!__glutCurrentWindow)
  160.             {
  161.                 __glutWarning("glutGet: no active window");
  162.                 return -1;
  163.             }
  164.             
  165.             return __glutCurrentWindow->parent ? __glutCurrentWindow->parent->num + 1 : 0;
  166.         case GLUT_WINDOW_NUM_CHILDREN:
  167.             if(!__glutCurrentWindow)
  168.             {
  169.                 __glutWarning("glutGet: no active window");
  170.                 return -1;
  171.             }
  172.             
  173.             {
  174.                 int num = 0;
  175.                 GLUTwindow *children = __glutCurrentWindow->children;
  176.  
  177.                 while (children)
  178.                 {
  179.                     num++;
  180.                     children = children->siblings;
  181.                 }
  182.                 return num;
  183.             }
  184.         case GLUT_WINDOW_NUM_SAMPLES:
  185.             return 0;
  186.         case GLUT_WINDOW_STEREO:
  187.             GET_CONFIG(AGL_STEREO);
  188.             return value;
  189.         case GLUT_WINDOW_CURSOR:
  190.             if(!__glutCurrentWindow)
  191.             {
  192.                 __glutWarning("glutGet: no active window");
  193.                 return -1;
  194.             }
  195.             
  196.             return __glutCurrentWindow->cursor;
  197.         case GLUT_SCREEN_WIDTH:
  198.             if(__glutCurrentWindow && __glutCurrentWindow->fullscreen) return __glutCurrentWindow->width;
  199.             
  200.             return (qd.screenBits.bounds.right - qd.screenBits.bounds.left);
  201.         case GLUT_SCREEN_HEIGHT:
  202.             if(__glutCurrentWindow && __glutCurrentWindow->fullscreen) return __glutCurrentWindow->height;
  203.             
  204.             return (qd.screenBits.bounds.bottom - qd.screenBits.bounds.top);
  205.         case GLUT_SCREEN_WIDTH_MM:
  206.             if(__glutCurrentWindow && __glutCurrentWindow->fullscreen) return __glutCurrentWindow->width;
  207.             
  208.             return (qd.screenBits.bounds.right - qd.screenBits.bounds.left);
  209.         case GLUT_SCREEN_HEIGHT_MM:
  210.             if(__glutCurrentWindow && __glutCurrentWindow->fullscreen) return __glutCurrentWindow->height;
  211.             
  212.             return (qd.screenBits.bounds.bottom - qd.screenBits.bounds.top);
  213.         case GLUT_MENU_NUM_ITEMS:
  214.             return __glutGetCurNumMenuItems();
  215.         case GLUT_DISPLAY_MODE_POSSIBLE:
  216.             {
  217.                 AGLPixelFormat vi;
  218.                 Bool dummy;
  219.  
  220.                 vi = __glutDetermineVisual(__glutDisplayMode, &dummy, __glutGetVisualInfo);
  221.                 if(vi)
  222.                 {
  223.                     aglDestroyPixelFormat(vi);
  224.                     return 1;
  225.                 }
  226.                 return 0;
  227.             }
  228.         case GLUT_ELAPSED_TIME:
  229.             {
  230.                 double beginning;
  231.  
  232.                 __glutInitTime(&beginning);
  233.                 return (int) (__glutTime() - beginning);
  234.             }
  235.         default:
  236.             __glutWarning("invalid glutGet parameter: %d", param);
  237.             return -1;
  238.     }
  239.     
  240.     return -1;
  241. }
  242.